home *** CD-ROM | disk | FTP | other *** search
/ Aminet 8 / Aminet 8 (1995)(GTI - Schatztruhe)[!][Oct 1995].iso / Aminet / dev / gcc / gcc270_src.lha / gcc-2.7.0-amiga / xcoffout.c < prev    next >
C/C++ Source or Header  |  1995-06-15  |  14KB  |  538 lines
  1. /* Output xcoff-format symbol table information from GNU compiler.
  2.    Copyright (C) 1992, 1994 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU CC.
  5.  
  6. GNU CC is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU CC is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU CC; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 59 Temple Place - Suite 330,
  19. Boston, MA 02111-1307, USA.  */
  20.  
  21.  
  22. /* Output xcoff-format symbol table data.  The main functionality is contained
  23.    in dbxout.c.  This file implements the sdbout-like parts of the xcoff
  24.    interface.  Many functions are very similar to their counterparts in
  25.    sdbout.c.  */
  26.  
  27. /* Include this first, because it may define MIN and MAX.  */
  28. #include <stdio.h>
  29.  
  30. #include "config.h"
  31. #include "tree.h"
  32. #include "rtl.h"
  33. #include "flags.h"
  34.  
  35. #ifdef XCOFF_DEBUGGING_INFO
  36.  
  37. /* This defines the C_* storage classes.  */
  38. #include <dbxstclass.h>
  39.  
  40. #include "xcoffout.h"
  41.  
  42. #if defined (USG) || defined (NO_STAB_H)
  43. #include "gstab.h"
  44. #else
  45. #include <stab.h>
  46.  
  47. /* This is a GNU extension we need to reference in this file.  */
  48. #ifndef N_CATCH
  49. #define N_CATCH 0x54
  50. #endif
  51. #endif
  52.  
  53. /* Line number of beginning of current function, minus one.
  54.    Negative means not in a function or not using xcoff.  */
  55.  
  56. int xcoff_begin_function_line = -1;
  57.  
  58. /* Name of the current include file.  */
  59.  
  60. char *xcoff_current_include_file;
  61.  
  62. /* Name of the current function file.  This is the file the `.bf' is
  63.    emitted from.  In case a line is emitted from a different file,
  64.    (by including that file of course), then the line number will be
  65.    absolute.  */
  66.  
  67. char *xcoff_current_function_file;
  68.  
  69. /* Names of bss and data sections.  These should be unique names for each
  70.    compilation unit.  */
  71.  
  72. char *xcoff_bss_section_name;
  73. char *xcoff_private_data_section_name;
  74. char *xcoff_read_only_section_name;
  75.  
  76. /* Last source file name mentioned in a NOTE insn.  */
  77.  
  78. char *xcoff_lastfile;
  79.  
  80. /* Macro definitions used below.  */
  81.  
  82. #define ABS_OR_RELATIVE_LINENO(LINENO)        \
  83.  (xcoff_current_include_file ? (LINENO) : (LINENO) - xcoff_begin_function_line)
  84.  
  85. /* Output source line numbers via ".line" rather than ".stabd".  */
  86. #define ASM_OUTPUT_SOURCE_LINE(FILE,LINENUM) \
  87.   do {                        \
  88.     if (xcoff_begin_function_line >= 0)        \
  89.       fprintf (FILE, "\t.line\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM)); \
  90.   } while (0)
  91.  
  92. #define ASM_OUTPUT_LFB(FILE,LINENUM) \
  93. {                        \
  94.   if (xcoff_begin_function_line == -1)        \
  95.     {                        \
  96.       xcoff_begin_function_line = (LINENUM) - 1;\
  97.       fprintf (FILE, "\t.bf\t%d\n", (LINENUM));    \
  98.     }                        \
  99.   xcoff_current_function_file            \
  100.     = (xcoff_current_include_file        \
  101.        ? xcoff_current_include_file : main_input_filename); \
  102. }
  103.  
  104. #define ASM_OUTPUT_LFE(FILE,LINENUM) \
  105.   do {                        \
  106.     fprintf (FILE, "\t.ef\t%d\n", (LINENUM));    \
  107.     xcoff_begin_function_line = -1;        \
  108.   } while (0)
  109.  
  110. #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
  111.   fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
  112.  
  113. #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
  114.   fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
  115.  
  116. /* Support routines for XCOFF debugging info.  */
  117.  
  118. /* Assign NUMBER as the stabx type number for the type described by NAME.
  119.    Search all decls in the list SYMS to find the type NAME.  */
  120.  
  121. static void
  122. assign_type_number (syms, name, number)
  123.      tree syms;
  124.      char *name;
  125.      int number;
  126. {
  127.   tree decl;
  128.  
  129.   for (decl = syms; decl; decl = TREE_CHAIN (decl))
  130.     if (DECL_NAME (decl)
  131.     && strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), name) == 0)
  132.       {
  133.     TREE_ASM_WRITTEN (decl) = 1;
  134.     TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = number;
  135.       }
  136. }
  137.  
  138. /* Setup gcc primitive types to use the XCOFF built-in type numbers where
  139.    possible.  */
  140.  
  141. void
  142. xcoff_output_standard_types (syms)
  143.      tree syms;
  144. {
  145.   /* Handle built-in C types here.  */
  146.  
  147.   assign_type_number (syms, "int", (TARGET_64BIT ? -31 : -1));
  148.   assign_type_number (syms, "char", -2);
  149.   assign_type_number (syms, "short int", -3);
  150.   assign_type_number (syms, "long int", (TARGET_64BIT ? -31 : -4));
  151.   assign_type_number (syms, "unsigned char", -5);
  152.   assign_type_number (syms, "signed char", -6);
  153.   assign_type_number (syms, "short unsigned int", -7);
  154.   assign_type_number (syms, "unsigned int", (TARGET_64BIT ? -32 : -8));
  155.   /* No such type "unsigned".  */
  156.   assign_type_number (syms, "long unsigned int", (TARGET_64BIT ? -32 : -10));
  157.   assign_type_number (syms, "void", -11);
  158.   assign_type_number (syms, "float", -12);
  159.   assign_type_number (syms, "double", -13);
  160.   assign_type_number (syms, "long double", -14);
  161.   /* Pascal and Fortran types run from -15 to -29.  */
  162.   assign_type_number (syms, "wchar", -30);
  163.   assign_type_number (syms, "long long int", -31);
  164.   assign_type_number (syms, "long long unsigned int", -32);
  165.   /* Additional Fortran types run from -33 to -37.  */
  166.  
  167.   /* ??? Should also handle built-in C++ and Obj-C types.  There perhaps
  168.      aren't any that C doesn't already have.  */
  169. }
  170.  
  171. /* Print an error message for unrecognized stab codes.  */
  172.  
  173. #define UNKNOWN_STAB(STR)    \
  174.    do { \
  175.      fprintf(stderr, "Error, unknown stab %s: : 0x%x\n", STR, stab); \
  176.      fflush (stderr);    \
  177.    } while (0)
  178.  
  179. /* Conversion routine from BSD stabs to AIX storage classes.  */
  180.  
  181. int
  182. stab_to_sclass (stab)
  183.      int stab;
  184. {
  185.   switch (stab)
  186.     {
  187.     case N_GSYM:
  188.       return C_GSYM;
  189.  
  190.     case N_FNAME:
  191.       UNKNOWN_STAB ("N_FNAME"); 
  192.       abort();
  193.  
  194.     case N_FUN:
  195.       return C_FUN;
  196.  
  197.     case N_STSYM:
  198.     case N_LCSYM:
  199.       return C_STSYM;
  200.  
  201. #ifdef N_MAIN
  202.     case N_MAIN:
  203.       UNKNOWN_STAB ("N_MAIN"); 
  204.       abort ();
  205. #endif
  206.  
  207.     case N_RSYM:
  208.       return C_RSYM;
  209.  
  210.     case N_SSYM:
  211.       UNKNOWN_STAB ("N_SSYM"); 
  212.       abort ();
  213.  
  214.     case N_RPSYM:
  215.       return C_RPSYM;
  216.  
  217.     case N_PSYM:
  218.       return C_PSYM;
  219.     case N_LSYM:
  220.       return C_LSYM;
  221.     case N_DECL:
  222.       return C_DECL;
  223.     case N_ENTRY:
  224.       return C_ENTRY;
  225.  
  226.     case N_SO:
  227.       UNKNOWN_STAB ("N_SO"); 
  228.       abort ();
  229.  
  230.     case N_SOL:
  231.       UNKNOWN_STAB ("N_SOL"); 
  232.       abort ();
  233.  
  234.     case N_SLINE:
  235.       UNKNOWN_STAB ("N_SLINE"); 
  236.       abort ();
  237.  
  238. #ifdef N_DSLINE
  239.     case N_DSLINE:
  240.       UNKNOWN_STAB ("N_DSLINE"); 
  241.       abort ();
  242. #endif
  243.  
  244. #ifdef N_BSLINE
  245.     case N_BSLINE:
  246.       UNKNOWN_STAB ("N_BSLINE"); 
  247.       abort ();
  248. #endif
  249. #if 0
  250.       /* This has the same value as N_BSLINE.  */
  251.     case N_BROWS:
  252.       UNKNOWN_STAB ("N_BROWS"); 
  253.       abort ();
  254. #endif
  255.  
  256. #ifdef N_BINCL
  257.     case N_BINCL:
  258.       UNKNOWN_STAB ("N_BINCL"); 
  259.       abort ();
  260. #endif
  261.  
  262. #ifdef N_EINCL
  263.     case N_EINCL:
  264.       UNKNOWN_STAB ("N_EINCL"); 
  265.       abort ();
  266. #endif
  267.  
  268. #ifdef N_EXCL
  269.     case N_EXCL:
  270.       UNKNOWN_STAB ("N_EXCL"); 
  271.       abort ();
  272. #endif
  273.  
  274.     case N_LBRAC:
  275.       UNKNOWN_STAB ("N_LBRAC"); 
  276.       abort ();
  277.  
  278.     case N_RBRAC:
  279.       UNKNOWN_STAB ("N_RBRAC"); 
  280.       abort ();
  281.  
  282.     case N_BCOMM:
  283.       return C_BCOMM;
  284.     case N_ECOMM:
  285.       return C_ECOMM;
  286.     case N_ECOML:
  287.       return C_ECOML;
  288.  
  289.     case N_LENG:
  290.       UNKNOWN_STAB ("N_LENG"); 
  291.       abort ();
  292.  
  293.     case N_PC:
  294.       UNKNOWN_STAB ("N_PC"); 
  295.       abort ();
  296.  
  297. #ifdef N_M2C
  298.     case N_M2C:
  299.       UNKNOWN_STAB ("N_M2C"); 
  300.       abort ();
  301. #endif
  302.  
  303. #ifdef N_SCOPE
  304.     case N_SCOPE:
  305.       UNKNOWN_STAB ("N_SCOPE"); 
  306.       abort ();
  307. #endif
  308.  
  309.     case N_CATCH:
  310.       UNKNOWN_STAB ("N_CATCH"); 
  311.       abort ();
  312.  
  313.     default:
  314.       UNKNOWN_STAB ("default"); 
  315.       abort ();
  316.   }
  317. }
  318.  
  319. /* In XCOFF, we have to have this .bf before the function prologue.
  320.    Rely on the value of `dbx_begin_function_line' not to duplicate .bf.  */
  321.  
  322. void
  323. xcoffout_output_first_source_line (file, last_linenum)
  324.      FILE *file;
  325.      int last_linenum;
  326. {
  327.   ASM_OUTPUT_LFB (file, last_linenum);
  328.   dbxout_parms (DECL_ARGUMENTS (current_function_decl));
  329.   ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
  330. }
  331.  
  332. /* Output debugging info to FILE to switch to sourcefile FILENAME.
  333.    INLINE_P is true if this is from an inlined function.  */
  334.  
  335. void
  336. xcoffout_source_file (file, filename, inline_p)
  337.      FILE *file;
  338.      char *filename;
  339.      int inline_p;
  340. {
  341.   if (filename
  342.       && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
  343.       || (inline_p && ! xcoff_current_include_file)
  344.       || (! inline_p && xcoff_current_include_file)))
  345.     {
  346.       if (xcoff_current_include_file)
  347.     {
  348.       fprintf (file, "\t.ei\t");
  349.       output_quoted_string (file, xcoff_current_include_file);
  350.       fprintf (file, "\n");
  351.       xcoff_current_include_file = NULL;
  352.     }
  353.       if (strcmp (main_input_filename, filename) || inline_p)
  354.     {
  355.       fprintf (file, "\t.bi\t");
  356.       output_quoted_string (file, filename);
  357.       fprintf (file, "\n");
  358.       xcoff_current_include_file = filename;
  359.     }
  360.  
  361.       xcoff_lastfile = filename;
  362.     }
  363. }
  364.  
  365. /* Output a line number symbol entry into output stream FILE,
  366.    for source file FILENAME and line number NOTE.  */
  367.  
  368. void
  369. xcoffout_source_line (file, filename, note)
  370.      FILE *file;
  371.      char *filename;
  372.      rtx note;
  373. {
  374.   xcoffout_source_file (file, filename, RTX_INTEGRATED_P (note));
  375.  
  376.   ASM_OUTPUT_SOURCE_LINE (file, NOTE_LINE_NUMBER (note));
  377. }
  378.  
  379. /* Output the symbols defined in block number DO_BLOCK.
  380.    Set NEXT_BLOCK_NUMBER to 0 before calling.
  381.  
  382.    This function works by walking the tree structure of blocks,
  383.    counting blocks until it finds the desired block.  */
  384.  
  385. static int do_block = 0;
  386.  
  387. static int next_block_number;
  388.  
  389. static void
  390. xcoffout_block (block, depth, args)
  391.      register tree block;
  392.      int depth;
  393.      tree args;
  394. {
  395.   while (block)
  396.     {
  397.       /* Ignore blocks never expanded or otherwise marked as real.  */
  398.       if (TREE_USED (block))
  399.     {
  400.       /* When we reach the specified block, output its symbols.  */
  401.       if (next_block_number == do_block)
  402.         {
  403.           /* Output the syms of the block.  */
  404.           if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
  405.         dbxout_syms (BLOCK_VARS (block));
  406.           if (args)
  407.         dbxout_reg_parms (args);
  408.  
  409.           /* We are now done with the block.  Don't go to inner blocks.  */
  410.           return;
  411.         }
  412.       /* If we are past the specified block, stop the scan.  */
  413.       else if (next_block_number >= do_block)
  414.         return;
  415.  
  416.       next_block_number++;
  417.  
  418.       /* Output the subblocks.  */
  419.       xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
  420.     }
  421.       block = BLOCK_CHAIN (block);
  422.     }
  423. }
  424.  
  425. /* Describe the beginning of an internal block within a function.
  426.    Also output descriptions of variables defined in this block.
  427.  
  428.    N is the number of the block, by order of beginning, counting from 1,
  429.    and not counting the outermost (function top-level) block.
  430.    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
  431.    if the count starts at 0 for the outermost one.  */
  432.  
  433. void
  434. xcoffout_begin_block (file, line, n)
  435.      FILE *file;
  436.      int line;
  437.      int n;
  438. {
  439.   tree decl = current_function_decl;
  440.  
  441.   
  442.   /* The IBM AIX compiler does not emit a .bb for the function level scope,
  443.      so we avoid it here also.  */
  444.   if (n != 1)
  445.     ASM_OUTPUT_LBB (file, line, n);
  446.  
  447.   do_block = n;
  448.   next_block_number = 0;
  449.   xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
  450. }
  451.  
  452. /* Describe the end line-number of an internal block within a function.  */
  453.  
  454. void
  455. xcoffout_end_block (file, line, n)
  456.      FILE *file;
  457.      int line;
  458.      int n;
  459. {
  460.   if (n != 1)
  461.     ASM_OUTPUT_LBE (file, line, n);
  462. }
  463.  
  464. /* Called at beginning of function (before prologue).
  465.    Declare function as needed for debugging.  */
  466.  
  467. void
  468. xcoffout_declare_function (file, decl, name)
  469.      FILE *file;
  470.      tree decl;
  471.      char *name;
  472. {
  473.   char *n = name;
  474.   int i;
  475.  
  476.   for (i = 0; name[i]; ++i)
  477.     {
  478.       if (name[i] == '[')
  479.     {
  480.       n = (char *) alloca (i + 1);
  481.       strncpy (n, name, i);
  482.       n[i] = '\0';
  483.       break;
  484.     }
  485.     }
  486.  
  487.   /* Any pending .bi or .ei must occur before the .function pseudo op.
  488.      Otherwise debuggers will think that the function is in the previous
  489.      file and/or at the wrong line number.  */
  490.   xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
  491.   dbxout_symbol (decl, 0);
  492.   fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n", n, n, n, n);
  493. }
  494.  
  495. /* Called at beginning of function body (after prologue).
  496.    Record the function's starting line number, so we can output
  497.    relative line numbers for the other lines.
  498.    Record the file name that this function is contained in.  */
  499.  
  500. void
  501. xcoffout_begin_function (file, last_linenum)
  502.      FILE *file;
  503.      int last_linenum;
  504. {
  505.   ASM_OUTPUT_LFB (file, last_linenum);
  506. }
  507.  
  508. /* Called at end of function (before epilogue).
  509.    Describe end of outermost block.  */
  510.  
  511. void
  512. xcoffout_end_function (file, last_linenum)
  513.      FILE *file;
  514.      int last_linenum;
  515. {
  516.   ASM_OUTPUT_LFE (file, last_linenum);
  517. }
  518.  
  519. /* Output xcoff info for the absolute end of a function.
  520.    Called after the epilogue is output.  */
  521.  
  522. void
  523. xcoffout_end_epilogue (file)
  524.      FILE *file;
  525. {
  526.   /* We need to pass the correct function size to .function, otherwise,
  527.      the xas assembler can't figure out the correct size for the function
  528.      aux entry.  So, we emit a label after the last instruction which can
  529.      be used by the .function pseudo op to calculate the function size.  */
  530.  
  531.   char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
  532.   if (*fname == '*')
  533.     ++fname;
  534.   fprintf (file, "FE..");
  535.   ASM_OUTPUT_LABEL (file, fname);
  536. }
  537. #endif /* XCOFF_DEBUGGING_INFO */
  538.